package com.sg.service.biz.app.impl;

import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.QueryEvaObjTargetCycleDetailReq;
import com.sg.dto.base.app.req.QueryTargetDetailReq;
import com.sg.dto.base.app.req.QueryTaskDetailReq;
import com.sg.dto.base.app.req.QueryTimerTaskPlanDetailReq;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.component.ImplementComparisonOfMultipleTimeTypesComReqDto;
import com.sg.dto.integration.component.ImplementComparisonOfMultipleTimeTypesComRespDto;
import com.sg.entity.OmsEvaluationObjectTargetCycle;
import com.sg.entity.OmsTarget;
import com.sg.entity.OmsTargetTimingTaskDispatch;
import com.sg.entity.OmsTask;
import com.sg.service.base.app.*;
import com.sg.service.biz.app.*;
import com.sg.service.biz.app.nb.NbConventionalScheduling;
import com.sg.common.exception.Assert;
import com.wicket.okrcomponent.integration.DivineDataService;
import com.wicket.okrcomponent.integration.InterfaceModeService;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.concurrent.Callable;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class ConventionalSchedulingServiceImpl
        implements com.wicket.okrapp.biz.service.ConventionalSchedulingService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private MOmsTargetService mOmsTargetService;
    @Resource
    private NbConventionalScheduling nbConventionalScheduling;
    //@Resource
    //private undefinedService undefinedService;
    @Resource
    private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
    @Resource
    private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
    @Resource
    private DivineDataService fwCompDivineDataClient;
    @Resource
    private TimingTaskService timingTaskService;
    @Resource
    private MOmsTaskService mOmsTaskService;
    @Resource
    private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
    @Resource
    private TaskGenService taskGenService;
    @Resource
    private IndexSystemService indexSystemService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private TargetContentService targetContentService;
    @Resource
    private TaskService taskService;
    @Resource
    private InterfaceModeService interfaceModeService;
//@Resource
    //private MCustomFields3Service mCustomFields3Service;

    /**
     * D3-执行调度是否可以执行判断(公共)[6606]
     * gen by moon at 6/6/2023, 1:40:33 AM
     */
    @Trace(operationName = "D3-执行调度是否可以执行判断(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementSchedulingCanBeExecuteComRespDto implementSchedulingCanBeExecuteCom(ImplementSchedulingCanBeExecuteComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
//virtualUsage 约定：是  41243
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq.setTureOrFalse("TRUE");//sourceId:928311_1_41243

        /*约定：是[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getTureOrFalse(), "D3-执行调度是否可以执行判断(公共)-约定：是-是否不能为空", false);
        receptionServiceRes = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq);


//virtualUsage 约定：否  41244
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:928412_1_41244

        /*约定：否[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_1.getTureOrFalse(), "D3-执行调度是否可以执行判断(公共)-约定：否-是否不能为空", false);
        receptionServiceRes_2 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_1);


        if ((reqDto != null && reqDto.getDispatchActionTypeCode() != null && reqDto.getDispatchActionTypeCode().equals("STAGE_CURRENT_CYCLE_ETC"))) {
            //if(D3-执行调度是否可以执行判断(公共).任务调度的行为类型编码 等于 调度更新执行周期阶段当前周期等（选用）)  41237

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_2.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41378
            }

            /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getTureOrFalse(), "D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空", false);
            receptionServiceRes_4 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_2);


            receptionServiceRes_5 = receptionServiceRes_4;
        } else if ((reqDto != null && reqDto.getDispatchActionTypeCode() != null && reqDto.getDispatchActionTypeCode().equals("FOUR_TREE_DEVIATION_DAYS_ETC") || reqDto != null && reqDto.getDispatchActionTypeCode() != null && reqDto.getDispatchActionTypeCode().equals("TIMING_TASK_AUTO_UPDATE_WEIGHT_SCORE"))) {
            //elseif((D3-执行调度是否可以执行判断(公共).任务调度的行为类型编码 等于 调度更新四棵树偏差天数等数据（选用） or D3-执行调度是否可以执行判断(公共).任务调度的行为类型编码 等于 调度自动更新权重分))  41379

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:929880_1_41380
            queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:929882_1_41380
            queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:929877_1_41380
            queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:929879_1_41380
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1012244_1_41380
                queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:929875_1_41380
                queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:929876_1_41380
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:929878_1_41380
            }

            /*3-3-09查目标内容父周期进展状态是否完成[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(), "D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-是否父周期不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTaskStatus() != null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("NOT_AT_THE") || omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTaskStatus() != null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("ONGOING"))) {
                //if((3-3-09查目标内容父周期进展状态是否完成.目标周期任务进展状态 等于 未开始 or 3-3-09查目标内容父周期进展状态是否完成.目标周期任务进展状态 等于 进行中))  41381

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_3.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41382
                }

                /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getTureOrFalse(), "D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空", false);
                receptionServiceRes_6 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_3);


                receptionServiceRes_5 = receptionServiceRes_6;
            } else if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTaskStatus() != null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("HAS_ENDED"))) {
                //elseif(3-3-09查目标内容父周期进展状态是否完成.目标周期任务进展状态 等于 已结束)  41383

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes_2 != null) {
                    receptionServiceReq_4.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41390
                }

                /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_4.getTureOrFalse(), "D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空", false);
                receptionServiceRes_7 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_4);


                receptionServiceRes_5 = receptionServiceRes_7;
            }
        } else if ((reqDto != null && reqDto.getDispatchActionTypeCode() != null && reqDto.getDispatchActionTypeCode().equals("TASK_OVERDUE_ETC"))) {
            //elseif(D3-执行调度是否可以执行判断(公共).任务调度的行为类型编码 等于 调度更新任务逾期等数据（选用）)  41384

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:929866_1_41385
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:929864_1_41385
                queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:929865_1_41385
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTargetCycleId(), "D3-执行调度是否可以执行判断(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3-执行调度是否可以执行判断(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(), "D3-执行调度是否可以执行判断(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            if ((omsEvaluationObjectTargetCycle_2 != null && omsEvaluationObjectTargetCycle_2.getTaskStatus() != null && omsEvaluationObjectTargetCycle_2.getTaskStatus().equals("NOT_AT_THE") || omsEvaluationObjectTargetCycle_2 != null && omsEvaluationObjectTargetCycle_2.getTaskStatus() != null && omsEvaluationObjectTargetCycle_2.getTaskStatus().equals("ONGOING"))) {
                //if((3-3-09查目标周期进展状态是否已完成.目标周期任务进展状态 等于 未开始 or 3-3-09查目标周期进展状态是否已完成.目标周期任务进展状态 等于 进行中))  41386

                OmsTask omsTask = null;
                QueryTaskDetailReq queryTaskDetailReq = new QueryTaskDetailReq();
                queryTaskDetailReq.setIsArchive("FALSE");//sourceId:940728_1_41690
                if (reqDto != null) {
                    queryTaskDetailReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:940723_1_41690
                    queryTaskDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:940727_1_41690
                }

                /*3-7-01查询任务详情[2522]   */
                Assert.isNull(queryTaskDetailReq.getTaskId(), "D3-执行调度是否可以执行判断(公共)-3-7-01查询任务详情-任务ID不能为空", false);
                Assert.isNull(queryTaskDetailReq.getThemeContentId(), "D3-执行调度是否可以执行判断(公共)-3-7-01查询任务详情-主题内容ID不能为空", false);
                Assert.isNull(queryTaskDetailReq.getIsArchive(), "D3-执行调度是否可以执行判断(公共)-3-7-01查询任务详情-是否存档不能为空", false);
                omsTask = mOmsTaskService.queryTaskDetail(queryTaskDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((omsTask != null && omsTask.getIsComplete() != null && omsTask.getIsComplete().equals("FALSE"))) {
                    //if(3-7-01查询任务状态.是否完成 等于 否)  41691

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_5.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41692
                    }

                    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_5.getTureOrFalse(), "D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空", false);
                    receptionServiceRes_8 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_5);


                    receptionServiceRes_5 = receptionServiceRes_8;
                } else if ((omsTask != null && omsTask.getIsComplete() != null && omsTask.getIsComplete().equals("TRUE"))) {
                    //elseif(3-7-01查询任务状态.是否完成 等于 是)  41693

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_9 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_6 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes_2 != null) {
                        receptionServiceReq_6.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41694
                    }

                    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_6.getTureOrFalse(), "D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空", false);
                    receptionServiceRes_9 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_6);


                    receptionServiceRes_5 = receptionServiceRes_9;
                }
            } else if ((omsEvaluationObjectTargetCycle_2 != null && omsEvaluationObjectTargetCycle_2.getTaskStatus() != null && omsEvaluationObjectTargetCycle_2.getTaskStatus().equals("HAS_ENDED"))) {
                //elseif(3-3-09查目标周期进展状态是否已完成.目标周期任务进展状态 等于 已结束)  41388

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_10 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_7 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes_2 != null) {
                    receptionServiceReq_7.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41389
                }

                /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_7.getTureOrFalse(), "D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空", false);
                receptionServiceRes_10 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_7);


                receptionServiceRes_5 = receptionServiceRes_10;
            }
        }
        ImplementSchedulingCanBeExecuteComRespDto retData = new ImplementSchedulingCanBeExecuteComRespDto();
        if (receptionServiceRes_5 != null) {
            retData.setTureOrFalse(receptionServiceRes_5.getTureOrFalse());//SimpleFieldAssign//sourceId:928801_1
        }


        return retData;
    }

    /**
     * D3-执行四棵树偏差天数等数据(公共)[6602]
     * gen by moon at 5/12/2023, 3:13:16 AM
     */
    @Trace(operationName = "D3-执行四棵树偏差天数等数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementFourTreeDeviationDaysEtcComRespDto implementFourTreeDeviationDaysEtcCom(ImplementFourTreeDeviationDaysEtcComReqDto reqDto) {

//
//      //virtualUsage M3异步开始（特殊方法）  41276
//      //ModelCode: asynchronizationStart
//Callable<String> call = new Callable<String>() {
//
//    @Override
//    public String call() throws Exception {
//        //执行方法
////virtualUsage M3执行业务应用公共字段推送内存（特殊方法）  41324
//      OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
//    Object unknown=new Object();
//  if(reqDto!=null){
//      unknown.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:929103_1_41324
//unknown.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:929104_1_41324
//unknown.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:929105_1_41324
//    }
//
//    /*M3执行业务应用公共字段推送内存（特殊方法）[4520]   */
//    Assert.isNull(unknown.getCreateInductionId(),"D3-执行四棵树偏差天数等数据(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建人就职记录ID 不能为空",false);
//Assert.isNull(unknown.getSpaceId(),"D3-执行四棵树偏差天数等数据(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于空间ID不能为空",false);
//Assert.isNull(unknown.getAppId(),"D3-执行四棵树偏差天数等数据(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于联盟应用ID不能为空",false);
//      omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.implementBizPublicFieldPushMemory(unknown)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
////virtualUsage D3-执行调度是否可以执行判断(公共)  41278
//      ImplementSchedulingCanBeExecuteComRespDto implementSchedulingCanBeExecuteComRespDto = null;
//    ImplementSchedulingCanBeExecuteComReqDto implementSchedulingCanBeExecuteComReqDto=new ImplementSchedulingCanBeExecuteComReqDto();
//
//
//    /*D3-执行调度是否可以执行判断(公共)[6606]   */
//    Assert.isNull(implementSchedulingCanBeExecuteComReqDto.getTargetId(),"D3-执行四棵树偏差天数等数据(公共)-D3-执行调度是否可以执行判断(公共)-冗余目标ID不能为空",false);
//      implementSchedulingCanBeExecuteComRespDto = implementSchedulingCanBeExecuteCom(implementSchedulingCanBeExecuteComReqDto)/*vcase invoke 同服务,同domain*/;
//
//
//
//if((implementSchedulingCanBeExecuteComRespDto!= null&&  implementSchedulingCanBeExecuteComRespDto.getTureOrFalse() !=null && implementSchedulingCanBeExecuteComRespDto.getTureOrFalse().equals("TRUE")&&reqDto!= null&&  reqDto.getTargetContentList() !=null && reqDto.getTargetContentList().size()>0)) {
//        //if((D3-执查询目标是否可用.是否 等于 是 and D3-执行四棵树偏差天数等数据(公共).目标内容列表数据集条数 大于 0))  41282
//
////ModelCode: circulationCollections
//        for (TargetContentDto circulationCollectionsRes: reqDto.getTargetContentList()){
//
//CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
//    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
//  checkTimeScopeSearchComReqDto.setCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:928863_1_41287
//if(circulationCollectionsRes!=null){
//      checkTimeScopeSearchComReqDto.setCompareTime(circulationCollectionsRes.getOperateTime());//SimpleFieldAssign//sourceId:928865_1_41287
//    }
//
//    /*D2检查时间范围查询(公共)[3297]   */
//    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3-执行四棵树偏差天数等数据(公共)-D2检查时间范围查询(公共)-当前时间不能为空",false);
//Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3-执行四棵树偏差天数等数据(公共)-D2检查时间范围查询(公共)-比较时间不能为空",false);
//      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("BEFORE"))) {
//        //if(D2检查时间范围查询(公共).时间比较结果 等于 之前（小于）)  41288
//
//OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
//    QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq=new QueryTimerTaskPlanDetailReq();
//  queryTimerTaskPlanDetailReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:928913_1_41289
//queryTimerTaskPlanDetailReq.setDispatchActionTypeCode("FOUR_TREE_DEVIATION_DAYS_ETC");//sourceId:928914_1_41289
//queryTimerTaskPlanDetailReq.setObjectTypeCode("OMS_TARGET");//sourceId:928915_1_41289
//queryTimerTaskPlanDetailReq.setIsCompensateTask("FALSE");//sourceId:928918_1_41289
//queryTimerTaskPlanDetailReq.setIsComplete("FALSE");//sourceId:928919_1_41289
//if(circulationCollectionsRes!=null){
//      queryTimerTaskPlanDetailReq.setObjectId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:928916_1_41289
//queryTimerTaskPlanDetailReq.setThemeContentId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:928917_1_41289
//    }
//
//    /*3-2-09查询定时任务调度详情[3187]   */
//    Assert.isNull(queryTimerTaskPlanDetailReq.getTaskDispatchTypeCode(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-任务调度类型编码不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getDispatchActionTypeCode(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-任务调度的行为类型编码不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getObjectTypeCode(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-归属对象类型编码不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getObjectId(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-归属对象内容ID不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getThemeContentId(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-主题内容ID不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getIsCompensateTask(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-是否补偿任务不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getIsComplete(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-是否执行完成不能为空",false);
//      omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
//if((omsTargetTimingTaskDispatch != null )) {
//        //if(3-2-09查询定时任务调度详情.出参 值不等于空 )  41290
//
//BatchRefreshTargetContentDeviationDaysEtcComRespDto batchRefreshTargetContentDeviationDaysEtcComRespDto = null;
//    if(omsTargetTimingTaskDispatch !=null){
//          BatchRefreshTargetContentDeviationDaysEtcComReqDto batchRefreshTargetContentDeviationDaysEtcComReqDto=new BatchRefreshTargetContentDeviationDaysEtcComReqDto();
//  if(omsTargetTimingTaskDispatch!=null){
//      batchRefreshTargetContentDeviationDaysEtcComReqDto.setTimingTaskDispatchId(omsTargetTimingTaskDispatch.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:927819_1_41291
//    }
//if(circulationCollectionsRes!=null){
//      batchRefreshTargetContentDeviationDaysEtcComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:927818_1_41291
//batchRefreshTargetContentDeviationDaysEtcComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:927817_1_41291
//batchRefreshTargetContentDeviationDaysEtcComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:927820_1_41291
//    }
//
//    /*D3-3批量更新目标内容偏差天数等数据(公共)[4724]   */
//    Assert.isNull(batchRefreshTargetContentDeviationDaysEtcComReqDto.getTimingTaskDispatchId(),"D3-执行四棵树偏差天数等数据(公共)-D3-3批量更新目标内容偏差天数等数据(公共)-定时任务调度记录ID不能为空",false);
//Assert.isNull(batchRefreshTargetContentDeviationDaysEtcComReqDto.getTargetCycleContentId(),"D3-执行四棵树偏差天数等数据(公共)-D3-3批量更新目标内容偏差天数等数据(公共)-关联目标内容ID不能为空",false);
//Assert.isNull(batchRefreshTargetContentDeviationDaysEtcComReqDto.getTargetCycleContentTypeCode(),"D3-执行四棵树偏差天数等数据(公共)-D3-3批量更新目标内容偏差天数等数据(公共)-关联目标内容类型编码不能为空",false);
//Assert.isNull(batchRefreshTargetContentDeviationDaysEtcComReqDto.getEvaluationTemplateId(),"D3-执行四棵树偏差天数等数据(公共)-D3-3批量更新目标内容偏差天数等数据(公共)-评价模板ID不能为空",false);
//      batchRefreshTargetContentDeviationDaysEtcComRespDto = timingTaskService.batchRefreshTargetContentDeviationDaysEtcCom(batchRefreshTargetContentDeviationDaysEtcComReqDto)/*vcase invoke isSameApp*/;
//
//
//
//           }
//      }
//      }
////ModelCode: circulationEnd
//        }
//
//      }
////virtualUsage M3异步结束（特殊方法）  41277
//      //ModelCode: asynchronizationEnd
//        return "";
//    }
//};
//CommonFunctionHelper.asynExcute(call);
        ImplementFourTreeDeviationDaysEtcComRespDto retData = new ImplementFourTreeDeviationDaysEtcComRespDto();


        return retData;
    }

    /**
     * D3-执行周期当前子周期及末级周期调度(公共)[6603]
     * gen by moon at 9/8/2023, 2:14:43 AM
     */
    @Trace(operationName = "D3-执行周期当前子周期及末级周期调度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementStageCurrentCycleEtcComRespDto implementStageCurrentCycleEtcCom(ImplementStageCurrentCycleEtcComReqDto reqDto) {

//
//      //virtualUsage M3异步开始  41229
//      //ModelCode: asynchronizationStart
//Callable<String> call = new Callable<String>() {
//
//    @Override
//    public String call() throws Exception {
//        //执行方法
////virtualUsage M3业务应用公共字段推送内存  41273
//      //ModelCode: publicFieldCache
//        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
//    ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBizPublicFieldPushMemoryReqDto();
//  if(reqDto!=null){
//      publicFieldCacheReq.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:928767_1_41273
//publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:928768_1_41273
//publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:928769_1_41273
//    }
//
//    /*M3业务应用公共字段推送内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
//    Assert.isNull(publicFieldCacheReq.getCreateInductionId(),"D3-执行周期当前子周期及末级周期调度(公共)-M3业务应用公共字段推送内存-创建人就职记录ID 不能为空",false);
//Assert.isNull(publicFieldCacheReq.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-M3业务应用公共字段推送内存-创建于空间ID不能为空",false);
//Assert.isNull(publicFieldCacheReq.getAppId(),"D3-执行周期当前子周期及末级周期调度(公共)-M3业务应用公共字段推送内存-创建于联盟应用ID不能为空",false);
//      publicFieldCacheRes = nbConventionalScheduling.implementBizPublicFieldPushMemory(publicFieldCacheReq);
//
//
//
////virtualUsage 3-3-06查目标列表  41226
//      List<OmsTarget> listOmsTarget =new ArrayList<>();
//    QueryTargetListReq queryTargetListReq=new QueryTargetListReq();
//  queryTargetListReq.setDataInitStatus("TRUE");//sourceId:927855_1_41226
//queryTargetListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:927850_1_41226
//queryTargetListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:927851_1_41226
//
//    /*3-3-06查目标列表[2452]   */
//    Assert.isNull(queryTargetListReq.getDataInitStatus(),"D3-执行周期当前子周期及末级周期调度(公共)-3-3-06查目标列表-数据初始化完成状态不能为空",false);
//Assert.isNull(queryTargetListReq.getSubjectLifeCycle(),"D3-执行周期当前子周期及末级周期调度(公共)-3-3-06查目标列表-主体生命周期不能为空",false);
//Assert.isNull(queryTargetListReq.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-3-3-06查目标列表-创建于空间ID不能为空",false);
//      listOmsTarget = mOmsTargetService.queryTargetList(queryTargetListReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
//if((listOmsTarget!= null&&  listOmsTarget !=null && listOmsTarget.size()>0)) {
//        //if(3-3-06查目标列表.目标列表数据集条数 大于 0)  41227
//
////ModelCode: circulationCollections
//        for (OmsTarget circulationCollectionsRes: listOmsTarget){
//
//ImplementComparisonOfMultipleTimeTypesComRespDto implementComparisonOfMultipleTimeTypesComRespDto = null;
//    ImplementComparisonOfMultipleTimeTypesComReqDto implementComparisonOfMultipleTimeTypesComReqDto=new ImplementComparisonOfMultipleTimeTypesComReqDto();
//  implementComparisonOfMultipleTimeTypesComReqDto.setTimeUnitType("DAY");//sourceId:1118335_1_48420
//implementComparisonOfMultipleTimeTypesComReqDto.setCaluStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1118337_1_48420
//if(circulationCollectionsRes!=null){
//      implementComparisonOfMultipleTimeTypesComReqDto.setCompareTime(circulationCollectionsRes.getOperateTime());//SimpleFieldAssign//sourceId:1118336_1_48420
//    }
//
//    /*D2-执行多时间类型对比(公共)[7376]   */
//    Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getTimeUnitType(),"D3-执行周期当前子周期及末级周期调度(公共)-D2-执行多时间类型对比(公共)-时间单位类型不能为空",false);
//Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getCaluStartTime(),"D3-执行周期当前子周期及末级周期调度(公共)-D2-执行多时间类型对比(公共)-参照时间不能为空",false);
//Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getCompareTime(),"D3-执行周期当前子周期及末级周期调度(公共)-D2-执行多时间类型对比(公共)-比较时间不能为空",false);
//      implementComparisonOfMultipleTimeTypesComRespDto = interfaceModeService.implementComparisonOfMultipleTimeTypesCom(implementComparisonOfMultipleTimeTypesComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetPgsStatus() !=null && circulationCollectionsRes.getTargetPgsStatus().equals("NOT_AT_THE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetPgsStatus() !=null && circulationCollectionsRes.getTargetPgsStatus().equals("ONGOING"))&&(implementComparisonOfMultipleTimeTypesComRespDto!= null&&  implementComparisonOfMultipleTimeTypesComRespDto.getTimeCompareResult() !=null && implementComparisonOfMultipleTimeTypesComRespDto.getTimeCompareResult().equals("BEFORE"))) {
//        //if((M3执行目标【循环开始】.目标进展状态 等于 未开始 or M3执行目标【循环开始】.目标进展状态 等于 进行中) and D2-判断当天是否已经更新过当前周期.时间比较结果 等于 之前（小于）)  41256
//
//OmsEvaluationTemplate omsEvaluationTemplate = null;
//    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
//  queryEvaTempDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:934489_1_41542
//if(circulationCollectionsRes!=null){
//      queryEvaTempDetailReq.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:950588_1_41542
//    }
//
//    /*3-2-02查评价模板详情[2316]   */
//    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-执行周期当前子周期及末级周期调度(公共)-3-2-02查评价模板详情-评价模板ID不能为空",false);
//Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(),"D3-执行周期当前子周期及末级周期调度(公共)-3-2-02查评价模板详情-主体生命周期不能为空",false);
//      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
//QueryStageCurrentCycleDetailComRespDto queryStageCurrentCycleDetailComRespDto = null;
//    if(omsEvaluationTemplate !=null){
//          QueryStageCurrentCycleDetailComReqDto queryStageCurrentCycleDetailComReqDto=new QueryStageCurrentCycleDetailComReqDto();
//  queryStageCurrentCycleDetailComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:934440_1_41539
//queryStageCurrentCycleDetailComReqDto.setDispatchActionTypeCode("STAGE_CURRENT_CYCLE_ETC");//sourceId:934441_1_41539
//queryStageCurrentCycleDetailComReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:934442_1_41539
//queryStageCurrentCycleDetailComReqDto.setAddRuleInfoTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:934444_1_41539
//queryStageCurrentCycleDetailComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:934446_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsCompensateTask("FALSE");//sourceId:934448_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsComplete("FALSE");//sourceId:934449_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsRoutineDispatchAction("TRUE");//sourceId:934450_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsRealTimeaSync("FALSE");//sourceId:934451_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:934452_1_41539
//if(omsEvaluationTemplate!=null){
//      queryStageCurrentCycleDetailComReqDto.setTargetContentName(omsEvaluationTemplate.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:934456_1_41539
//    }
//if(circulationCollectionsRes!=null){
//      queryStageCurrentCycleDetailComReqDto.setObjectId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:934443_1_41539
//queryStageCurrentCycleDetailComReqDto.setAddRuleInfoId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:934445_1_41539
//queryStageCurrentCycleDetailComReqDto.setThemeContentId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:934447_1_41539
//    }
//
//    /*D3-查询常规调度详情(公共)[6630]   */
//    Assert.isNull(queryStageCurrentCycleDetailComReqDto.getTargetContentName(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-目标内容名称不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getTaskDispatchTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-任务调度类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getDispatchActionTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-任务调度的行为类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getObjectTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-归属对象类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getObjectId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-归属对象内容ID不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getAddRuleInfoTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-生成规则信息类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getAddRuleInfoId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-生成辅助规则信息值不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getThemeContentTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-主题内容类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getThemeContentId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-主题内容ID不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsCompensateTask(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否补偿任务不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsComplete(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否执行完成不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsRoutineDispatchAction(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否常规任务调度不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsRealTimeaSync(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否实时异步调度不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsAppointSimpleMq(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否固化消息队列不能为空",false);
//      queryStageCurrentCycleDetailComRespDto = queryStageCurrentCycleDetailCom(queryStageCurrentCycleDetailComReqDto)/*vcase invoke 同服务,同domain*/;
//
//
//
//           }
//if((queryStageCurrentCycleDetailComRespDto!= null&& queryStageCurrentCycleDetailComRespDto.getTimingTaskDispatchId() != null )) {
//        //if(D3-查执行周期更新当前周期调度详情(公共).定时任务调度记录ID 值不等于空 )  41272
//
//RefreshStageCurrentCycleEtcComRespDto refreshStageCurrentCycleEtcComRespDto = null;
//    if(queryStageCurrentCycleDetailComRespDto !=null){
//          RefreshStageCurrentCycleEtcComReqDto refreshStageCurrentCycleEtcComReqDto=new RefreshStageCurrentCycleEtcComReqDto();
//  refreshStageCurrentCycleEtcComReqDto.setIsSubCycle("TRUE");//sourceId:927602_1_41274
//refreshStageCurrentCycleEtcComReqDto.setSystemCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:927605_1_41274
//refreshStageCurrentCycleEtcComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:927604_1_41274
//if(queryStageCurrentCycleDetailComRespDto!=null){
//      refreshStageCurrentCycleEtcComReqDto.setTimingTaskDispatchId(queryStageCurrentCycleDetailComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:927606_1_41274
//    }
//if(circulationCollectionsRes!=null){
//      refreshStageCurrentCycleEtcComReqDto.setTargetId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:927603_1_41274
//    }
//
//    /*D3-3更新周期阶段当前周期等(公共)[3358]   */
//    Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getTimingTaskDispatchId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-定时任务调度记录ID不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getIsSubCycle(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-是否子周期不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getTargetId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-冗余目标ID不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getSystemCurrentTime(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-系统当前时间不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-创建于空间ID不能为空",false);
//      refreshStageCurrentCycleEtcComRespDto = timingTaskService.refreshStageCurrentCycleEtcCom(refreshStageCurrentCycleEtcComReqDto)/*vcase invoke isSameApp*/;
//
//
//
//           }
//RefreshStageCurrentCycleEtcComRespDto refreshStageCurrentCycleEtcComRespDto_1 = null;
//    if(queryStageCurrentCycleDetailComRespDto !=null){
//          RefreshStageCurrentCycleEtcComReqDto refreshStageCurrentCycleEtcComReqDto_1=new RefreshStageCurrentCycleEtcComReqDto();
//  refreshStageCurrentCycleEtcComReqDto_1.setSystemCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:927611_1_41275
//refreshStageCurrentCycleEtcComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:927610_1_41275
//if(queryStageCurrentCycleDetailComRespDto!=null){
//      refreshStageCurrentCycleEtcComReqDto_1.setTimingTaskDispatchId(queryStageCurrentCycleDetailComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:927612_1_41275
//    }
//if(circulationCollectionsRes!=null){
//      refreshStageCurrentCycleEtcComReqDto_1.setTargetId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:927609_1_41275
//    }
//
//    /*D3-3更新周期阶段当前周期等(公共)[3358]   */
//    Assert.isNull(refreshStageCurrentCycleEtcComReqDto_1.getTimingTaskDispatchId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-定时任务调度记录ID不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto_1.getTargetId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-冗余目标ID不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto_1.getSystemCurrentTime(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-系统当前时间不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto_1.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-创建于空间ID不能为空",false);
//      refreshStageCurrentCycleEtcComRespDto_1 = timingTaskService.refreshStageCurrentCycleEtcCom(refreshStageCurrentCycleEtcComReqDto_1)/*vcase invoke isSameApp*/;
//
//
//
//           }
//ImplementGeneralTaskPlanProcessingComRespDto implementGeneralTaskPlanProcessingComRespDto = null;
//    if(queryStageCurrentCycleDetailComRespDto !=null){
//          ImplementGeneralTaskPlanProcessingComReqDto implementGeneralTaskPlanProcessingComReqDto=new ImplementGeneralTaskPlanProcessingComReqDto();
//  implementGeneralTaskPlanProcessingComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:946988_1_41801
//implementGeneralTaskPlanProcessingComReqDto.setDispatchActionTypeCode("STAGE_CURRENT_CYCLE_ETC");//sourceId:946989_1_41801
//implementGeneralTaskPlanProcessingComReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:946990_1_41801
//implementGeneralTaskPlanProcessingComReqDto.setIsCompensateTask("FALSE");//sourceId:946992_1_41801
//implementGeneralTaskPlanProcessingComReqDto.setIsComplete("TRUE");//sourceId:946993_1_41801
//if(queryStageCurrentCycleDetailComRespDto!=null){
//      implementGeneralTaskPlanProcessingComReqDto.setTimingTaskDispatchId(queryStageCurrentCycleDetailComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:946995_1_41801
//    }
//if(circulationCollectionsRes!=null){
//      implementGeneralTaskPlanProcessingComReqDto.setObjectId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:946991_1_41801
//    }
//if(reqDto!=null){
//      implementGeneralTaskPlanProcessingComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:946994_1_41801
//    }
//
//    /*D3执行常规调度任务处理(公共)[5413]   */
//    Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getTimingTaskDispatchId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-定时任务调度记录ID不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getTaskDispatchTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-任务调度类型编码不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getDispatchActionTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-任务调度的行为类型编码不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getObjectTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-归属对象类型编码不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getObjectId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-归属对象内容ID不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getIsCompensateTask(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-是否补偿任务不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getIsComplete(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-是否执行完成不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-创建于空间ID不能为空",false);
//      implementGeneralTaskPlanProcessingComRespDto = taskGenService.implementGeneralTaskPlanProcessingCom(implementGeneralTaskPlanProcessingComReqDto)/*vcase invoke isSameApp*/;
//
//
//
//           }
//      }
//      }
//// TODO: 2023/8/22
//else if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetPgsStatus() !=null && circulationCollectionsRes.getTargetPgsStatus().equals("HAS_ENDED"))){
//       //elseif(M3执行目标【循环开始】.目标进展状态 等于 已结束)  41257
//
////processBranchName:继续循环 ,processBranchId:41258
//        continue;
//    }
////ModelCode: circulationEnd
//        }
//
//      }
////virtualUsage M3异步结束  41230
//      //ModelCode: asynchronizationEnd
//        return "";
//    }
//};
//CommonFunctionHelper.asynExcute(call);
//ImplementStageCurrentCycleEtcComRespDto retData = new ImplementStageCurrentCycleEtcComRespDto();
//
//


        return null;
    }

    /**
     * D3-执行目标完成状态校验(公共)[6620]
     * gen by moon at 10/3/2023, 6:42:33 PM
     */
    @Trace(operationName = "D3-执行目标完成状态校验(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCheckTargetIsDoneComRespDto implementCheckTargetIsDoneCom(ImplementCheckTargetIsDoneComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
//virtualUsage 约定：是  41397
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq.setTureOrFalse("TRUE");//sourceId:930822_1_41397

        /*约定：是[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getTureOrFalse(), "D3-执行目标完成状态校验(公共)-约定：是-是否不能为空", false);
        receptionServiceRes = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq);


//virtualUsage 约定：否  41398
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:930826_1_41398

        /*约定：否[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_1.getTureOrFalse(), "D3-执行目标完成状态校验(公共)-约定：否-是否不能为空", false);
        receptionServiceRes_2 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_1);


//virtualUsage 3-3-01查目标详情  41399
        OmsTarget omsTarget = null;
        QueryTargetDetailReq queryTargetDetailReq = new QueryTargetDetailReq();
        queryTargetDetailReq.setIsArchive("FALSE");//sourceId:930934_1_41399
        if (reqDto != null) {
            queryTargetDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:930933_1_41399
        }

        /*3-3-01查目标详情[2488]   */
        Assert.isNull(queryTargetDetailReq.getTargetId(), "D3-执行目标完成状态校验(公共)-3-3-01查目标详情-目标ID不能为空", false);
        Assert.isNull(queryTargetDetailReq.getIsArchive(), "D3-执行目标完成状态校验(公共)-3-3-01查目标详情-是否存档不能为空", false);
        omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsTarget != null && omsTarget.getTargetPgsStatus() != null && omsTarget.getTargetPgsStatus().equals("NOTSTARTED") || omsTarget != null && omsTarget.getTargetPgsStatus() != null && omsTarget.getTargetPgsStatus().equals("ONGOING"))) {
            //if((3-3-01查目标详情.目标进展状态 等于 未开始 or 3-3-01查目标详情.目标进展状态 等于 进行中))  41400

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_2.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:930946_1_41401
            }

            /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getTureOrFalse(), "D3-执行目标完成状态校验(公共)-约定出参：是否可用-是否不能为空", false);
            receptionServiceRes_4 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_2);


            receptionServiceRes_5 = receptionServiceRes_4;
        } else if ((omsTarget != null && omsTarget.getTargetPgsStatus() != null && omsTarget.getTargetPgsStatus().equals("FINISHED"))) {
            //elseif(3-3-01查目标详情.目标进展状态 等于 已结束)  41402

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_3.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:930946_1_41403
            }

            /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getTureOrFalse(), "D3-执行目标完成状态校验(公共)-约定出参：是否可用-是否不能为空", false);
            receptionServiceRes_6 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_3);


            receptionServiceRes_5 = receptionServiceRes_6;
        }
        ImplementCheckTargetIsDoneComRespDto retData = new ImplementCheckTargetIsDoneComRespDto();
        if (receptionServiceRes_5 != null) {
            retData.setTureOrFalse(receptionServiceRes_5.getTureOrFalse());//SimpleFieldAssign//sourceId:930947_1
        }


        return retData;
    }

    /**
     * D3-查询常规调度详情(公共)[6630]
     * gen by moon at 10/2/2023, 5:16:50 PM
     */
    @Trace(operationName = "D3-查询常规调度详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryStageCurrentCycleDetailComRespDto queryStageCurrentCycleDetailCom(QueryStageCurrentCycleDetailComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage 3-2-09查询定时任务调度详情  41533
        OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
        QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq = new QueryTimerTaskPlanDetailReq();
        queryTimerTaskPlanDetailReq.setIsComplete("FALSE");//sourceId:934387_1_41533
        queryTimerTaskPlanDetailReq.setIsCompensateTask("FALSE");//sourceId:934386_1_41533
        if (reqDto != null) {
            queryTimerTaskPlanDetailReq.setTaskDispatchTypeCode(reqDto.getTaskDispatchTypeCode());//SimpleFieldAssign//sourceId:934378_1_41533
            queryTimerTaskPlanDetailReq.setDispatchActionTypeCode(reqDto.getDispatchActionTypeCode());//SimpleFieldAssign//sourceId:934379_1_41533
            queryTimerTaskPlanDetailReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:934381_1_41533
            queryTimerTaskPlanDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:934385_1_41533
        }

        /*3-2-09查询定时任务调度详情[3187]   */
        Assert.isNull(queryTimerTaskPlanDetailReq.getTaskDispatchTypeCode(), "D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-任务调度类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getDispatchActionTypeCode(), "D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-任务调度的行为类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getObjectId(), "D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-归属对象内容ID不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getThemeContentId(), "D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-主题内容ID不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getIsComplete(), "D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-是否执行完成不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getIsCompensateTask(), "D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-是否补偿任务不能为空", false);
        omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsTargetTimingTaskDispatch == null)) {
            //if(3-2-09查询定时任务调度详情.出参 值等于空 )  41534

            AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
            AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto = new AddTimerTaskPlanComReqDto();
            addTimerTaskPlanComReqDto.setIsRealTimeaSync("FALSE");//sourceId:934436_1_41535
            addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:934425_1_41535
            addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:934435_1_41535
            addTimerTaskPlanComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:934434_1_41535
            addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:934437_1_41535
            addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:934438_1_41535
            addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:934439_1_41535
            if (reqDto != null) {
                addTimerTaskPlanComReqDto.setTargetContentName(reqDto.getTargetContentName());//SimpleFieldAssign//sourceId:934491_1_41535
                addTimerTaskPlanComReqDto.setTaskName(reqDto.getTaskName());//SimpleFieldAssign//sourceId:946958_1_41535
                addTimerTaskPlanComReqDto.setTaskDispatchTypeCode(reqDto.getTaskDispatchTypeCode());//SimpleFieldAssign//sourceId:934427_1_41535
                addTimerTaskPlanComReqDto.setDispatchActionTypeCode(reqDto.getDispatchActionTypeCode());//SimpleFieldAssign//sourceId:934426_1_41535
                addTimerTaskPlanComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:934428_1_41535
                addTimerTaskPlanComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:934429_1_41535
                addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode(reqDto.getAddRuleInfoTypeCode());//SimpleFieldAssign//sourceId:934430_1_41535
                addTimerTaskPlanComReqDto.setAddRuleInfoId(reqDto.getAddRuleInfoId());//SimpleFieldAssign//sourceId:934431_1_41535
                addTimerTaskPlanComReqDto.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:934432_1_41535
                addTimerTaskPlanComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:934433_1_41535
                addTimerTaskPlanComReqDto.setStandbyField1(reqDto.getStandbyField1());//SimpleFieldAssign//sourceId:1011375_1_41535
                addTimerTaskPlanComReqDto.setStandbyField2(reqDto.getStandbyField2());//SimpleFieldAssign//sourceId:1011376_1_41535
            }

            /*D3新增定时任务调度(公共)[4995]   */
            Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getObjectTypeCode(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-归属对象类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getObjectId(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-归属对象内容ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-主题内容类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-主题内容ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getIsRealTimeaSync(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-是否实时异步调度不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-是否执行完成不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getIsAppointSimpleMq(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-是否固化消息队列不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-操作人就职记录ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-创建于空间ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getAppId(), "D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-创建于联盟应用ID不能为空", false);
            addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            if (addTimerTaskPlanComRespDto != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
                if (addTimerTaskPlanComRespDto != null) {
                    receptionServiceReq.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:934368_1_41536
                }

                /*约定出参：定时任务调度记录ID[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getTimingTaskDispatchId(), "D3-查询常规调度详情(公共)-约定出参：定时任务调度记录ID-定时任务调度记录ID不能为空", false);
                receptionServiceRes = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((omsTargetTimingTaskDispatch != null)) {
            //elseif(3-2-09查询定时任务调度详情.出参 值不等于空 )  41537

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            if (omsTargetTimingTaskDispatch != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                if (omsTargetTimingTaskDispatch != null) {
                    receptionServiceReq_1.setTimingTaskDispatchId(omsTargetTimingTaskDispatch.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:934368_1_41538
                }

                /*约定出参：定时任务调度记录ID[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getTimingTaskDispatchId(), "D3-查询常规调度详情(公共)-约定出参：定时任务调度记录ID-定时任务调度记录ID不能为空", false);
                receptionServiceRes_2 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        QueryStageCurrentCycleDetailComRespDto retData = new QueryStageCurrentCycleDetailComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setTimingTaskDispatchId(receptionServiceRes_1.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:934371_1
        }


        return retData;
    }

    /**
     * D3-执行任务逾期调度(公共)[6604]
     * gen by moon at 1/20/2024, 2:02:20 PM
     */
    @Trace(operationName = "D3-执行任务逾期调度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTaskOverdueEtcComRespDto implementTaskOverdueEtcCom(ImplementTaskOverdueEtcComReqDto reqDto) {


        //virtualUsage M3异步开始  41295
//      ModelCode: asynchronizationStart
        Callable<String> call = new Callable<String>() {

            @Override
            public String call() throws Exception {
                //执行方法
//virtualUsage M3执行业务应用公共字段推送内存（特殊方法）  41321
                //ModelCode: publicFieldCache
                ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
                ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq = new ImplementBizPublicFieldPushMemoryReqDto();
                if (reqDto != null) {
                    publicFieldCacheReq.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:929090_1_41321
                    publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:929091_1_41321
                    publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:929092_1_41321
                }

                /*M3执行业务应用公共字段推送内存（特殊方法）[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
                Assert.isNull(publicFieldCacheReq.getCreateInductionId(), "D3-执行任务逾期调度(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建人就职记录ID 不能为空", false);
                Assert.isNull(publicFieldCacheReq.getSpaceId(), "D3-执行任务逾期调度(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于空间ID不能为空", false);
                Assert.isNull(publicFieldCacheReq.getAppId(), "D3-执行任务逾期调度(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于联盟应用ID不能为空", false);
                publicFieldCacheRes = nbConventionalScheduling.implementBizPublicFieldPushMemory(publicFieldCacheReq);


                if ((reqDto != null && reqDto.getReportingTaskList() != null && reqDto.getReportingTaskList().size() > 0)) {
                    //if(D3-执行任务逾期调度(公共).汇报任务列表数据集条数 大于 0)  41298

//ModelCode: circulationCollections
                    for (ReportingTaskDto circulationCollectionsRes : reqDto.getReportingTaskList()) {

                        ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto = null;
                        ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto = new ImplementConcurrentBehaviorThemeLockComReqDto();
                        implementConcurrentBehaviorThemeLockComReqDto.setBehaviorThemeLockCode("REPORT_TASK_OVERDUE_STATUS_MSG_NUM_SWIPES");//sourceId:1490374_1_59777
                        implementConcurrentBehaviorThemeLockComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1490379_1_59777
                        implementConcurrentBehaviorThemeLockComReqDto.setTimeUnitType("MINUTES");//sourceId:1490380_1_59777
                        implementConcurrentBehaviorThemeLockComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1490382_1_59777
                        implementConcurrentBehaviorThemeLockComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1490381_1_59777
                        if (circulationCollectionsRes != null) {
                            implementConcurrentBehaviorThemeLockComReqDto.setCommPrimaryKey(circulationCollectionsRes.getTaskId());//SimpleFieldAssign//sourceId:1490375_1_59777
                        }

                        /*D3执行并发行为主题上锁(公共)[8296]   */
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getBehaviorThemeLockCode(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-行为主题锁不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getCommPrimaryKey(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-通用主键ID不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getDuration(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-锁定时长不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getTimeUnitType(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-时间单位类型不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getHandlingMethodConcurrentLockFailure(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-并发上锁失败处理方式不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getPreventConcurrentLockingUnlocking(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-防并发上锁or解锁不能为空", false);
                        implementConcurrentBehaviorThemeLockComRespDto = interfaceModeService.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto)/*vcase invoke isSameApp*/;


                        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
                        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
                        if (circulationCollectionsRes != null) {
                            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getParentEntityId());//SimpleFieldAssign//sourceId:1469713_1_58813
                        }
                        if (reqDto != null) {
                            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1469714_1_58813
                        }

                        /*3-3-09查当前牌目标进展状态是否完成[2313]   */
                        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-执行任务逾期调度(公共)-3-3-09查当前牌目标进展状态是否完成-被评对象目标周期ID不能为空", false);
                        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行任务逾期调度(公共)-3-3-09查当前牌目标进展状态是否完成-冗余评价模板ID不能为空", false);
                        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
                        Assert.isTrue(omsEvaluationObjectTargetCycle == null || omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId() == null, "找不到数据，系统异常", false);


                        if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTaskStatus() != null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("NOT_AT_THE") || omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTaskStatus() != null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("ONGOING")) && (implementConcurrentBehaviorThemeLockComRespDto != null && implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations() != null && implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
                            //if((3-3-09查当前牌目标进展状态是否完成.目标周期任务进展状态 等于 未开始 or 3-3-09查当前牌目标进展状态是否完成.目标周期任务进展状态 等于 进行中) and D3执行并发行为主题上锁(公共).防并发上锁情况 等于 空上锁成功)  58814

                            RefreshReportTaskStatusMsgAndMsgNumComRespDto refreshReportTaskStatusMsgAndMsgNumComRespDto = null;
                            RefreshReportTaskStatusMsgAndMsgNumComReqDto refreshReportTaskStatusMsgAndMsgNumComReqDto = new RefreshReportTaskStatusMsgAndMsgNumComReqDto();
                            refreshReportTaskStatusMsgAndMsgNumComReqDto.setStatusBizOptType("AUTO_ORDER");//sourceId:1468467_1_58815
                            refreshReportTaskStatusMsgAndMsgNumComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1468469_1_58815
                            refreshReportTaskStatusMsgAndMsgNumComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1468470_1_58815
                            if (circulationCollectionsRes != null) {
                                refreshReportTaskStatusMsgAndMsgNumComReqDto.setTaskId(circulationCollectionsRes.getTaskId());//SimpleFieldAssign//sourceId:1468468_1_58815
                            }

                            /*D3-更新汇报任务状态及消息与数量(公共)[8263]   */
                            Assert.isNull(refreshReportTaskStatusMsgAndMsgNumComReqDto.getStatusBizOptType(), "D3-执行任务逾期调度(公共)-D3-更新汇报任务状态及消息与数量(公共)-状态业务操作类型不能为空", false);
                            Assert.isNull(refreshReportTaskStatusMsgAndMsgNumComReqDto.getTaskId(), "D3-执行任务逾期调度(公共)-D3-更新汇报任务状态及消息与数量(公共)-任务ID不能为空", false);
                            Assert.isNull(refreshReportTaskStatusMsgAndMsgNumComReqDto.getSpaceId(), "D3-执行任务逾期调度(公共)-D3-更新汇报任务状态及消息与数量(公共)-创建于空间ID不能为空", false);
                            Assert.isNull(refreshReportTaskStatusMsgAndMsgNumComReqDto.getAppId(), "D3-执行任务逾期调度(公共)-D3-更新汇报任务状态及消息与数量(公共)-创建于联盟应用ID不能为空", false);
                            refreshReportTaskStatusMsgAndMsgNumComRespDto = taskService.refreshReportTaskStatusMsgAndMsgNumCom(refreshReportTaskStatusMsgAndMsgNumComReqDto)/*vcase invoke isSameApp*/;


                            ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_2 = null;
                            ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_1 = new ImplementConcurrentBehaviorThemeLockComReqDto();
                            implementConcurrentBehaviorThemeLockComReqDto_1.setBehaviorThemeLockCode("REPORT_TASK_OVERDUE_STATUS_MSG_NUM_SWIPES");//sourceId:1490396_1_59878
                            implementConcurrentBehaviorThemeLockComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1490398_1_59878
                            implementConcurrentBehaviorThemeLockComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1490399_1_59878
                            if (circulationCollectionsRes != null) {
                                implementConcurrentBehaviorThemeLockComReqDto_1.setCommPrimaryKey(circulationCollectionsRes.getTaskId());//SimpleFieldAssign//sourceId:1490397_1_59878
                            }

                            /*D3执行并发行为主题解锁(公共)[8296]   */
                            Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getBehaviorThemeLockCode(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                            Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getCommPrimaryKey(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                            Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getPreventConcurrentLockingUnlocking(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                            Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getWhetherUnlockBulk(), "D3-执行任务逾期调度(公共)-D3执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                            implementConcurrentBehaviorThemeLockComRespDto_2 = interfaceModeService.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_1)/*vcase invoke isSameApp*/;


                        }
//ModelCode: circulationEnd
                    }

                }
//virtualUsage M3异步结束  41296
                //ModelCode: asynchronizationEnd
                return "";
            }
        };
        CommonFunctionHelper.asynExcute(call);
        ImplementTaskOverdueEtcComRespDto retData = new ImplementTaskOverdueEtcComRespDto();


        return retData;
    }

    /**
     * D3-执行四棵树偏差天数调度&目标周期进展状态(公共)[6602]
     * gen by moon at 4/7/2024, 3:24:28 PM
     */
    @Trace(operationName = "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementFourTreeDeviationDaysEtcScheduleComRespDto implementFourTreeDeviationDaysEtcScheduleCom(ImplementFourTreeDeviationDaysEtcScheduleComReqDto reqDto) {


        //virtualUsage M3异步开始（特殊方法）  41276
        //ModelCode: asynchronizationStart
        Callable<String> call = new Callable<String>() {

            @Override
            public String call() throws Exception {
                //执行方法
//virtualUsage M3执行业务应用公共字段推送内存（特殊方法）  41324
                //ModelCode: publicFieldCache
                ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
                ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq = new ImplementBizPublicFieldPushMemoryReqDto();
                if (reqDto != null) {
                    publicFieldCacheReq.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:929103_1_41324
                    publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:929104_1_41324
                    publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:929105_1_41324
                }

                /*M3执行业务应用公共字段推送内存（特殊方法）[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */

                publicFieldCacheRes = nbConventionalScheduling.implementBizPublicFieldPushMemory(publicFieldCacheReq);


//virtualUsage M3执行目标内容ID发牌【循环开始】  49315
//ModelCode: circulationCollections
                for (TargetContentDto circulationCollectionsRes : reqDto.getTargetContentList()) {

//virtualUsage 3-3-09查目标周期详情（获取目标内容信息）  49317
                    OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
                    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
                    queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1151296_1_49317
                    if (circulationCollectionsRes != null) {
                        queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1151294_1_49317
                        queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151295_1_49317
                    }

                    /*3-3-09查目标周期详情（获取目标内容信息）[2313]   */
                    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查目标周期详情（获取目标内容信息）-被评对象目标周期ID不能为空", false);
                    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查目标周期详情（获取目标内容信息）-冗余评价模板ID不能为空", false);
                    Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查目标周期详情（获取目标内容信息）-是否存档不能为空", false);
                    omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage D2对比当前时间与操作时间（用于判断是否需要继续执行）  49318
                    ImplementComparisonOfMultipleTimeTypesComRespDto implementComparisonOfMultipleTimeTypesComRespDto = null;
                    if (omsEvaluationObjectTargetCycle != null) {
                        ImplementComparisonOfMultipleTimeTypesComReqDto implementComparisonOfMultipleTimeTypesComReqDto = new ImplementComparisonOfMultipleTimeTypesComReqDto();
                        implementComparisonOfMultipleTimeTypesComReqDto.setTimeUnitType("DAY");//sourceId:1118327_1_49318
                        implementComparisonOfMultipleTimeTypesComReqDto.setCaluStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1118329_1_49318
                        if (omsEvaluationObjectTargetCycle != null) {
                            implementComparisonOfMultipleTimeTypesComReqDto.setCompareTime(omsEvaluationObjectTargetCycle.getOperateTime());//SimpleFieldAssign//sourceId:1118328_1_49318
                        }

                        /*D2对比当前时间与操作时间（用于判断是否需要继续执行）[7376]   */
                        Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getTimeUnitType(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D2对比当前时间与操作时间（用于判断是否需要继续执行）-时间单位类型不能为空", false);
                        Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getCaluStartTime(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D2对比当前时间与操作时间（用于判断是否需要继续执行）-参照时间不能为空", false);
                        Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getCompareTime(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D2对比当前时间与操作时间（用于判断是否需要继续执行）-比较时间不能为空", false);
                        implementComparisonOfMultipleTimeTypesComRespDto = interfaceModeService.implementComparisonOfMultipleTimeTypesCom(implementComparisonOfMultipleTimeTypesComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
//virtualUsage D3执行并发行为主题上锁(公共)  59847
                    ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto = null;
                    if (omsEvaluationObjectTargetCycle != null) {
                        ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto = new ImplementConcurrentBehaviorThemeLockComReqDto();
                        implementConcurrentBehaviorThemeLockComReqDto.setBehaviorThemeLockCode("FOUR_TREE_DEVIATION_DAYS_DISPATCH_SWIPES");//sourceId:1491008_1_59847
                        implementConcurrentBehaviorThemeLockComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1491011_1_59847
                        implementConcurrentBehaviorThemeLockComReqDto.setTimeUnitType("MINUTES");//sourceId:1491012_1_59847
                        implementConcurrentBehaviorThemeLockComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1491013_1_59847
                        implementConcurrentBehaviorThemeLockComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1491014_1_59847
                        if (omsEvaluationObjectTargetCycle != null) {
                            implementConcurrentBehaviorThemeLockComReqDto.setCommPrimaryKey(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1491009_1_59847
                            implementConcurrentBehaviorThemeLockComReqDto.setCustomField1(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1491010_1_59847
                        }

                        /*D3执行并发行为主题上锁(公共)[8296]   */
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getBehaviorThemeLockCode(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-行为主题锁不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getCommPrimaryKey(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-通用主键ID不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getCustomField1(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-自定义字段1不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getDuration(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-锁定时长不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getTimeUnitType(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-时间单位类型不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getHandlingMethodConcurrentLockFailure(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-并发上锁失败处理方式不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getPreventConcurrentLockingUnlocking(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-防并发上锁or解锁不能为空", false);
                        implementConcurrentBehaviorThemeLockComRespDto = interfaceModeService.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto)/*vcase invoke isSameApp*/;


                    }
                    if ((implementComparisonOfMultipleTimeTypesComRespDto != null && implementComparisonOfMultipleTimeTypesComRespDto.getTimeCompareResult() != null && implementComparisonOfMultipleTimeTypesComRespDto.getTimeCompareResult().equals("BEFORE") && implementConcurrentBehaviorThemeLockComRespDto != null && implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations() != null && implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
                        //if((D2对比当前时间与操作时间（用于判断是否需要继续执行）.时间比较结果 等于 之前（小于） and D3执行并发行为主题上锁(公共).防并发上锁情况 等于 空上锁成功))  49319

                        if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTaskStatus() != null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("NOT_AT_THE") || omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTaskStatus() != null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("ONGOING"))) {
                            //if((3-3-09查目标周期详情（获取目标内容信息）.目标周期任务进展状态 等于 未开始 or 3-3-09查目标周期详情（获取目标内容信息）.目标周期任务进展状态 等于 进行中))  49321

                            RefreshFourTreeDeviationDaysEtcComRespDto refreshFourTreeDeviationDaysEtcComRespDto = null;
                            if (omsEvaluationObjectTargetCycle != null) {
                                RefreshFourTreeDeviationDaysEtcComReqDto refreshFourTreeDeviationDaysEtcComReqDto = new RefreshFourTreeDeviationDaysEtcComReqDto();
                                if (omsEvaluationObjectTargetCycle != null) {
                                    refreshFourTreeDeviationDaysEtcComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1151308_1_49322
                                    refreshFourTreeDeviationDaysEtcComReqDto.setSpaceId(omsEvaluationObjectTargetCycle.getSpaceId());//SimpleFieldAssign//sourceId:1151309_1_49322
                                }

                                /*D3-3更新四棵树偏差天数等数据(公共)[3361]   */
                                Assert.isNull(refreshFourTreeDeviationDaysEtcComReqDto.getEvaObjTargetCycleId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3-3更新四棵树偏差天数等数据(公共)-被评对象目标周期ID不能为空", false);
                                Assert.isNull(refreshFourTreeDeviationDaysEtcComReqDto.getSpaceId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3-3更新四棵树偏差天数等数据(公共)-创建于空间ID不能为空", false);
                                refreshFourTreeDeviationDaysEtcComRespDto = timingTaskService.refreshFourTreeDeviationDaysEtcCom(refreshFourTreeDeviationDaysEtcComReqDto)/*vcase invoke isSameApp*/;


                            }
                            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
                            if (omsEvaluationObjectTargetCycle != null) {
                                QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
                                queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentTypeCode("TARGET");//sourceId:1151402_1_49329
                                queryEvaObjTargetCycleDetailReq_1.setIsParentCycle("TRUE");//sourceId:1151403_1_49329
                                queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1151405_1_49329
                                if (omsEvaluationObjectTargetCycle != null) {
                                    queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1151400_1_49329
                                    queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1151401_1_49329
                                    queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151404_1_49329
                                }

                                /*3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）[2313]   */
                                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-被评对象内容表主键ID不能为空", false);
                                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-被评对象类型编码不能为空", false);
                                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentTypeCode(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-关联目标内容类型编码不能为空", false);
                                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsParentCycle(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-是否父周期不能为空", false);
                                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-冗余评价模板ID不能为空", false);
                                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-是否存档不能为空", false);
                                omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                            }
                            if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode() != null && omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY") || omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode() != null && omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
                                //if((3-3-09查目标周期详情（获取目标内容信息）.关联目标内容类型编码 等于 目标分类 or 3-3-09查目标周期详情（获取目标内容信息）.关联目标内容类型编码 等于 指标))  49325

                                ImplementInitializeUpdateTargetContCurrentCycleComRespDto implementInitializeUpdateTargetContCurrentCycleComRespDto = null;
                                if (omsEvaluationObjectTargetCycle != null) {
                                    ImplementInitializeUpdateTargetContCurrentCycleComReqDto implementInitializeUpdateTargetContCurrentCycleComReqDto = new ImplementInitializeUpdateTargetContCurrentCycleComReqDto();
                                    if (omsEvaluationObjectTargetCycle != null) {
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetContentName(omsEvaluationObjectTargetCycle.getCyclelAlias());//SimpleFieldAssign//sourceId:1151312_1_49326
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetCycleContentTypeCode(omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1151315_1_49326
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1151316_1_49326
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1151314_1_49326
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto.setEvaluationTemplateId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151313_1_49326
                                    }

                                    /*D3执行更新目标分类或指标当前及下一周期(公共)[7473]   */
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetContentName(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-目标内容名称不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetCycleContentTypeCode(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-关联目标内容类型编码不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetCycleContentId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-关联目标内容ID不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-冗余目标ID不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getEvaluationTemplateId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-冗余评价模板ID不能为空", false);
                                    implementInitializeUpdateTargetContCurrentCycleComRespDto = targetContentService.implementInitializeUpdateTargetContCurrentCycleCom(implementInitializeUpdateTargetContCurrentCycleComReqDto)/*vcase invoke isSameApp*/;


                                }
                                ImplementInitializeUpdateTargetContCurrentCycleComRespDto implementInitializeUpdateTargetContCurrentCycleComRespDto_1 = null;
                                if (omsEvaluationObjectTargetCycle_2 != null && omsEvaluationObjectTargetCycle != null) {
                                    ImplementInitializeUpdateTargetContCurrentCycleComReqDto implementInitializeUpdateTargetContCurrentCycleComReqDto_1 = new ImplementInitializeUpdateTargetContCurrentCycleComReqDto();
                                    implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setTargetCycleContentTypeCode("TARGET");//sourceId:1151321_1_49327
                                    if (omsEvaluationObjectTargetCycle_2 != null) {
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setTargetContentName(omsEvaluationObjectTargetCycle_2.getCyclelAlias());//SimpleFieldAssign//sourceId:1151318_1_49327
                                    }
                                    if (omsEvaluationObjectTargetCycle != null) {
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1151322_1_49327
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1151320_1_49327
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setEvaluationTemplateId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151319_1_49327
                                    }

                                    /*D3执行更新目标当前及下一周期(公共)[7473]   */
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getTargetContentName(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-目标内容名称不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getTargetCycleContentTypeCode(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-关联目标内容类型编码不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getTargetCycleContentId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-关联目标内容ID不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getTargetId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-冗余目标ID不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getEvaluationTemplateId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-冗余评价模板ID不能为空", false);
                                    implementInitializeUpdateTargetContCurrentCycleComRespDto_1 = targetContentService.implementInitializeUpdateTargetContCurrentCycleCom(implementInitializeUpdateTargetContCurrentCycleComReqDto_1)/*vcase invoke isSameApp*/;


                                }
                            } else if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode() != null && omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode().equals("TARGET"))) {
                                //elseif(3-3-09查目标周期详情（获取目标内容信息）.关联目标内容类型编码 等于 目标)  49330

                                ImplementInitializeUpdateTargetContCurrentCycleComRespDto implementInitializeUpdateTargetContCurrentCycleComRespDto_2 = null;
                                if (omsEvaluationObjectTargetCycle_2 != null && omsEvaluationObjectTargetCycle != null) {
                                    ImplementInitializeUpdateTargetContCurrentCycleComReqDto implementInitializeUpdateTargetContCurrentCycleComReqDto_2 = new ImplementInitializeUpdateTargetContCurrentCycleComReqDto();
                                    implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setTargetCycleContentTypeCode("TARGET");//sourceId:1151321_1_49331
                                    if (omsEvaluationObjectTargetCycle_2 != null) {
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setTargetContentName(omsEvaluationObjectTargetCycle_2.getCyclelAlias());//SimpleFieldAssign//sourceId:1151318_1_49331
                                    }
                                    if (omsEvaluationObjectTargetCycle != null) {
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1151322_1_49331
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1151320_1_49331
                                        implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setEvaluationTemplateId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151319_1_49331
                                    }

                                    /*D3执行更新目标当前及下一周期(公共)[7473]   */
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getTargetContentName(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-目标内容名称不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getTargetCycleContentTypeCode(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-关联目标内容类型编码不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getTargetCycleContentId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-关联目标内容ID不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getTargetId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-冗余目标ID不能为空", false);
                                    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getEvaluationTemplateId(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-冗余评价模板ID不能为空", false);
                                    implementInitializeUpdateTargetContCurrentCycleComRespDto_2 = targetContentService.implementInitializeUpdateTargetContCurrentCycleCom(implementInitializeUpdateTargetContCurrentCycleComReqDto_2)/*vcase invoke isSameApp*/;


                                }
                            }
                        }
                    }
//virtualUsage D3执行并发行为主题解锁(公共)  59848
                    ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_2 = null;
                    if (omsEvaluationObjectTargetCycle != null) {
                        ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_1 = new ImplementConcurrentBehaviorThemeLockComReqDto();
                        implementConcurrentBehaviorThemeLockComReqDto_1.setBehaviorThemeLockCode("FOUR_TREE_DEVIATION_DAYS_DISPATCH_SWIPES");//sourceId:1490997_1_59848
                        implementConcurrentBehaviorThemeLockComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1491004_1_59848
                        implementConcurrentBehaviorThemeLockComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1491007_1_59848
                        if (omsEvaluationObjectTargetCycle != null) {
                            implementConcurrentBehaviorThemeLockComReqDto_1.setCommPrimaryKey(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1490998_1_59848
                            implementConcurrentBehaviorThemeLockComReqDto_1.setCustomField1(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1490999_1_59848
                        }

                        /*D3执行并发行为主题解锁(公共)[8296]   */
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getBehaviorThemeLockCode(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getCommPrimaryKey(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getCustomField1(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-自定义字段1不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getPreventConcurrentLockingUnlocking(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                        Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getWhetherUnlockBulk(), "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                        implementConcurrentBehaviorThemeLockComRespDto_2 = interfaceModeService.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_1)/*vcase invoke isSameApp*/;


                    }
//virtualUsage M3-执行【循环结束】  49316
//ModelCode: circulationEnd
                }

//virtualUsage M3异步结束（特殊方法）  41277
                //ModelCode: asynchronizationEnd
                return "";
            }
        };
        CommonFunctionHelper.asynExcute(call);
        ImplementFourTreeDeviationDaysEtcScheduleComRespDto retData = new ImplementFourTreeDeviationDaysEtcScheduleComRespDto();


        return retData;
    }
    //
}
